package path.calculator;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

public class PathCalculator {
    private int nodeCount;

    HashMap<Character, String> pathFromTo = new HashMap<Character, String>();

    public PathCalculator(int nodeCount) {
        this.nodeCount = nodeCount;
    }

    public int totalPaths() {
        PermutationGenerator generator = new PermutationGenerator(nodeCount);

        List<String> allPermutations = generator.allPermutations();

        List<String> validPermutations = new LinkedList<String>();

        for (String current : allPermutations)
            if (isValidPermutation(current))
                validPermutations.add(current);

        return validPermutations.size();
    }

    private boolean isValidPermutation(String current) {
        for (int fromIndex = current.length() - 1; fromIndex > 0; --fromIndex)
            for (int toIndex = fromIndex - 1; toIndex >= 0; --toIndex)
                if (pathExistsBetween(current.charAt(toIndex), current.charAt(fromIndex)))
                    return false;

        return true;
    }

    private boolean pathExistsBetween(T a, T b) {
        return pathFromTo.containsKey(a) && pathFromTo.get(a).contains(b);
    }

    public void mustFlowFromNodeToNode(T previous, T latter) {
        if (!pathFromTo.containsKey(previous))
            pathFromTo.put(previous, new ArrayList<T>());

        pathFromTo.get(previous).add(latter);
    }
}
